'use strict'

const Service = require('egg').Service
const { Op } = require('sequelize')

class SysPermissionService extends Service {
  /**
   * 查询 post - 权限 permission
   * @param {Object} data 请求参数
   * @property {String} data.permission_id - id
   * @property {String} data.permission_name - 名称
   */
  async permissionList(data) {
    // 简表不做分页
    const { ctx, app } = this

    // 权限校验
    ctx.checkAuthority('permission', ['permissionList'])

    // 数据库连接
    const db = app.model.SysPermission

    // 查询条件处理
    const conditions = {}

    // 查询语句
    const quary = {}
    if (data.permission_id) {
      quary.permission_id = { [Op.like]: `%${data.permission_id || ''}%` }
    }
    if (data.permission_name) {
      quary.permission_name = { [Op.like]: `%${data.permission_name || ''}%` }
    }
    conditions.where = quary

    // 其他
    conditions.order = [['created_at', 'ASC']] // 排序
    conditions.attributes = {
      exclude: ['updated_at'] // 排除字段
    }

    // 查询操作
    const res = await db.findAll(conditions)

    ctx.result({
      data: res,
      msg: '列表获取成功'
    })
  }

  /**
   * 新增 post - 权限 permission
   * @param {Object} data 请求参数
   * @property {String} data.permission_id - id
   * @property {String} data.permission_name - 名称
   * @property {String} data.remark - 备注
   */
  async permissionAdd(data) {
    const { ctx, app } = this

    // 权限校验
    ctx.checkAuthority('permission', ['permissionAdd'])

    data = Object.assign(
      {
        permission_id: ''
      },
      data
    )

    if (!data.permission_id) {
      return ctx.throw(400, { msg: 'permission_id 必填' })
    }

    // 数据库连接
    const db = app.model.SysPermission

    // 查询条件处理
    const conditions = { where: { permission_id: data.permission_id } }

    const one = await db.findOne(conditions)
    if (one) {
      return ctx.throw(400, { msg: '新增项已存在' })
    }

    const res = await db.create(data)

    ctx.result({
      data: res,
      msg: '新增成功'
    })
  }

  /**
   * 修改 post - 权限 permission
   * @param {Object} data 请求参数
   * @property {String} data.permission_id - id
   * @property {String} data.permission_name - 名称
   * @property {String} data.remark - 备注
   */
  async permissionUpdate(data) {
    const { ctx, app } = this

    // 权限校验
    ctx.checkAuthority('permission', ['permissionUpdate'])

    data = Object.assign(
      {
        permission_id: ''
      },
      data
    )

    if (!data.permission_id) {
      return ctx.throw(400, { msg: 'permission_id 必填' })
    }

    // 数据库连接
    const db = app.model.SysPermission

    // 查询条件处理
    const conditions = { where: { permission_id: data.permission_id } }

    const one = await db.findOne(conditions)
    if (!one) {
      return ctx.throw(400, { msg: '修改项不存在' })
    }

    const res = await db.update(data, conditions)

    ctx.result({
      data: res,
      msg: '修改成功'
    })
  }

  /**
   * 删除 post - 权限 permission
   * @param {Object} data 请求参数
   * @property {String} data.permission_id - id
   */
  async permissionDelete(data) {
    const { ctx, app } = this

    // 权限校验
    ctx.checkAuthority('permission', ['permissionDelete'])

    data = Object.assign(
      {
        permission_id: ''
      },
      data
    )

    if (!data.permission_id) {
      return ctx.throw(400, { msg: 'permission_id 必填' })
    }

    // 数据库连接
    const db = app.model.SysPermission

    // 查询条件处理
    const conditions = { where: { permission_id: data.permission_id } }

    const one = await db.findOne(conditions)
    if (!one) {
      return ctx.throw(400, { msg: '删除项不存在' })
    }

    const res = await db.destroy(conditions)

    ctx.result({
      data: res,
      msg: '删除成功'
    })
  }

  /**
   * 批量新增 post - 权限 permission
   * @param {Object} data
   * @property {Array} data.list - 批量新增项
   * @property {Boolean} data.cover - 是否覆盖 默认true
   */
  async permissionAddBatch(data) {
    const { ctx, app } = this

    // 权限校验
    ctx.checkAuthority('permission', ['permissionAddBatch'])

    data = Object.assign(
      {
        list: [], // 批量添加项
        cover: true // 是否覆盖
      },
      data
    )

    if (!Array.isArray(data.list)) {
      return ctx.throw(400, { msg: 'list 必须是数组' })
    }

    if (data.list.length == 0) {
      return ctx.throw(400, { msg: 'list 为空' })
    }

    // 数据库连接
    const db = app.model.SysPermission
    // 主键 mysql主键字段设置为UNIQUE，否则将会导致覆盖添加失效
    const primaryKey = 'permission_id'
    // 覆盖字段
    const updateOnDuplicate = ['permission_id', 'permission_name', 'remark']

    // 过滤掉主键缺失无效的项
    data.list = data.list.filter((item) => item[primaryKey])

    // 如果是增量模式
    if (!data.cover) {
      const existingIds = await db.findAll({
        attributes: [primaryKey],
        where: {
          [primaryKey]: {
            [Op.in]: data.list.map((item) => item[primaryKey])
          }
        }
      })

      // 过滤掉已存在的primaryKey
      const existingIdsSet = new Set(existingIds.map((item) => item[primaryKey]))
      data.list = data.list.filter((item) => !existingIdsSet.has(item[primaryKey]))
    }

    // 注意：这里不再需要区分cover的options，因为增量逻辑已在之前处理
    const res = await db.bulkCreate(data.list, { validate: true, updateOnDuplicate })

    ctx.result({
      data: res,
      msg: data.cover ? '批量覆盖添加成功' : '批量增量添加成功'
    })
  }

  /**
   * 批量删除 post - 权限 permission
   * @param {Object} data
   * @property {Array} data.list - 批量删除项
   */
  async permissionDeleteBatch(data) {
    const { ctx, app } = this

    // 权限校验
    ctx.checkAuthority('permission', ['permissionDeleteBatch'])

    data = Object.assign(
      {
        list: [] // 需要删除的记录的主键列表
      },
      data
    )

    if (!Array.isArray(data.list)) {
      return ctx.throw(400, { msg: 'list 必须是数组' })
    }

    if (data.list.length == 0) {
      return ctx.throw(400, { msg: 'list 为空' })
    }

    // 数据库连接
    const db = app.model.SysPermission
    // 主键 mysql主键字段设置为UNIQUE，否则将会导致覆盖添加失效
    const primaryKey = 'permission_id'

    // 执行批量删除
    const res = await db.destroy({
      where: {
        [primaryKey]: {
          [Op.in]: data.list
        }
      }
    })

    if (res == 0) {
      return ctx.throw(400, { msg: '无有效数据项删除' })
    }

    ctx.result({
      data: res,
      msg: '批量删除成功'
    })
  }
}

module.exports = SysPermissionService
